16 research outputs found
Two new results about quantum exact learning
We present two new results about exact learning by quantum computers. First,
we show how to exactly learn a -Fourier-sparse -bit Boolean function from
uniform quantum examples for that function. This
improves over the bound of uniformly random classical
examples (Haviv and Regev, CCC'15). Our main tool is an improvement of Chang's
lemma for the special case of sparse functions. Second, we show that if a
concept class can be exactly learned using quantum membership
queries, then it can also be learned using classical membership queries. This improves the
previous-best simulation result (Servedio and Gortler, SICOMP'04) by a -factor.Comment: v3: 21 pages. Small corrections and clarification
Separations between Combinatorial Measures for Transitive Functions
The role of symmetry in Boolean functions has been
extensively studied in complexity theory. For example, symmetric functions,
that is, functions that are invariant under the action of , is an
important class of functions in the study of Boolean functions. A function
is called transitive (or weakly-symmetric) if there
exists a transitive group of such that is invariant under the
action of - that is the function value remains unchanged even after the
bits of the input of are moved around according to some permutation . Understanding various complexity measures of transitive functions has
been a rich area of research for the past few decades.
In this work, we study transitive functions in light of several combinatorial
measures. We look at the maximum separation between various pairs of measures
for transitive functions. Such study for general Boolean functions has been
going on for past many years. The best-known results for general Boolean
functions have been nicely compiled by Aaronson et. al (STOC, 2021).
The separation between a pair of combinatorial measures is shown by
constructing interesting functions that demonstrate the separation. But many of
the celebrated separation results are via the construction of functions (like
"pointer functions" from Ambainis et al. (JACM, 2017) and "cheat-sheet
functions" Aaronson et al. (STOC, 2016)) that are not transitive. Hence, we
don't have such separation between the pairs of measures for transitive
functions.
In this paper we show how to modify some of these functions to construct
transitive functions that demonstrate similar separations between pairs of
combinatorial measures
Randomized and quantum query complexities of finding a king in a tournament
A tournament is a complete directed graph. It is well known that every
tournament contains at least one vertex v such that every other vertex is
reachable from v by a path of length at most 2. All such vertices v are called
*kings* of the underlying tournament. Despite active recent research in the
area, the best-known upper and lower bounds on the deterministic query
complexity (with query access to directions of edges) of finding a king in a
tournament on n vertices are from over 20 years ago, and the bounds do not
match: the best-known lower bound is Omega(n^{4/3}) and the best-known upper
bound is O(n^{3/2}) [Shen, Sheng, Wu, SICOMP'03]. Our contribution is to show
essentially *tight* bounds (up to logarithmic factors) of Theta(n) and
Theta(sqrt{n}) in the *randomized* and *quantum* query models, respectively. We
also study the randomized and quantum query complexities of finding a maximum
out-degree vertex in a tournament
Query Complexity of Global Minimum Cut
In this work, we resolve the query complexity of global minimum cut problem for a graph by designing a randomized algorithm for approximating the size of minimum cut in a graph, where the graph can be accessed through local queries like Degree, Neighbor, and Adjacency queries.
Given ? ? (0,1), the algorithm with high probability outputs an estimate t? satisfying the following (1-?) t ? t? ? (1+?) t, where t is the size of minimum cut in the graph. The expected number of local queries used by our algorithm is min{m+n,m/t}poly(log n,1/(?)) where n and m are the number of vertices and edges in the graph, respectively. Eden and Rosenbaum showed that ?(m/t) local queries are required for approximating the size of minimum cut in graphs, {but no local query based algorithm was known. Our algorithmic result coupled with the lower bound of Eden and Rosenbaum [APPROX 2018] resolve the query complexity of the problem of estimating the size of minimum cut in graphs using local queries.}
Building on the lower bound of Eden and Rosenbaum, we show that, for all t ? ?, ?(m) local queries are required to decide if the size of the minimum cut in the graph is t or t-2. Also, we show that, for any t ? ?, ?(m) local queries are required to find all the minimum cut edges even if it is promised that the input graph has a minimum cut of size t. Both of our lower bound results are randomized, and hold even if we can make Random Edge queries in addition to local queries
Counting and Sampling from Substructures Using Linear Algebraic Queries
For an unknown n × n matrix A having non-negative entries, the inner product (IP) oracle takes as inputs a specified row (or a column) of A and a vector v E Rⁿ with non-negative entries, and returns their inner product. Given two input vectors x and y in Rⁿ with non-negative entries, and an unknown matrix A with non-negative entries with IP oracle access, we design almost optimal sublinear time algorithms for the following two fundamental matrix problems:
- Find an estimate X for the bilinear form x^T A y such that X ≈ x^T A y.
- Designing a sampler Z for the entries of the matrix A such that P(Z = (i,j)) ≈ x_i A_{ij} y_j /(x^T A y), where x_i and y_j are i-th and j-th coordinate of x and y respectively. As special cases of the above results, for any submatrix of an unknown matrix with non-negative entries and IP oracle access, we can efficiently estimate the sum of the entries of any submatrix, and also sample a random entry from the submatrix with probability proportional to its weight. We will show that the above results imply that if we are given IP oracle access to the adjacency matrix of a graph, with non-negative weights on the edges, then we can design sublinear time algorithms for the following two fundamental graph problems:
- Estimating the sum of the weights of the edges of an induced subgraph, and
- Sampling edges proportional to their weights from an induced subgraph. We show that compared to the classical local queries (degree, adjacency, and neighbor queries) on graphs, we can get a quadratic speedup if we use IP oracle access for the above two problems.
Apart from the above, we study several matrix problems through the lens of IP oracle, like testing if the matrix is diagonal, symmetric, doubly stochastic, etc. Note that IP oracle is in the class of linear algebraic queries used lately in a series of works by Ben-Eliezer et al. [SODA'08], Nisan [SODA'21], Rashtchian et al. [RANDOM'20], Sun et al. [ICALP'19], and Shi and Woodruff [AAAI'19]. Recently, IP oracle was used by Bishnu et al. [RANDOM'21] to estimate dissimilarities between two matrices
Quantum Query-To-Communication Simulation Needs a Logarithmic Overhead
Buhrman, Cleve and Wigderson (STOC'98) observed that for every Boolean
function and the two-party bounded-error quantum communication complexity of is , where is the bounded-error quantum query
complexity of . Note that the bounded-error randomized communication
complexity of is bounded by , where denotes
the bounded-error randomized query complexity of . Thus, the BCW simulation
has an extra factor appearing that is absent in classical
simulation. A natural question is if this factor can be avoided. H{\o}yer and
de Wolf (STACS'02) showed that for the Set-Disjointness function, this can be
reduced to for some constant , and subsequently Aaronson and
Ambainis (FOCS'03) showed that this factor can be made a constant. That is, the
quantum communication complexity of the Set-Disjointness function (which is
) is .
Perhaps somewhat surprisingly, we show that when , then
the extra factor in the BCW simulation is unavoidable. In other words,
we exhibit a total function such that .
To the best of our knowledge, it was not even known prior to this work
whether there existed a total function and 2-bit function , such
that
On the Composition of Randomized Query Complexity and Approximate Degree
For any Boolean functions f and g, the question whether R(f?g) = ??(R(f) ? R(g)), is known as the composition question for the randomized query complexity. Similarly, the composition question for the approximate degree asks whether deg?(f?g) = ??(deg?(f)?deg?(g)). These questions are two of the most important and well-studied problems in the field of analysis of Boolean functions, and yet we are far from answering them satisfactorily.
It is known that the measures compose if one assumes various properties of the outer function f (or inner function g). This paper extends the class of outer functions for which R and deg? compose.
A recent landmark result (Ben-David and Blais, 2020) showed that R(f?g) = ?(noisyR(f)? R(g)). This implies that composition holds whenever noisyR(f) = ??(R(f)). We show two results:
1. When R(f) = ?(n), then noisyR(f) = ?(R(f)). In other words, composition holds whenever the randomized query complexity of the outer function is full.
2. If R composes with respect to an outer function, then noisyR also composes with respect to the same outer function. On the other hand, no result of the type deg?(f?g) = ?(M(f) ? deg?(g)) (for some non-trivial complexity measure M(?)) was known to the best of our knowledge. We prove that deg?(f?g) = ??(?{bs(f)} ? deg?(g)), where bs(f) is the block sensitivity of f. This implies that deg? composes when deg?(f) is asymptotically equal to ?{bs(f)}.
It is already known that both R and deg? compose when the outer function is symmetric. We also extend these results to weaker notions of symmetry with respect to the outer function
On the Composition of Randomized Query Complexity and Approximate Degree
For any Boolean functions and , the question whether , is known as the composition question for the
randomized query complexity. Similarly, the composition question for the
approximate degree asks whether . These questions are
two of the most important and well-studied problems, and yet we are far from
answering them satisfactorily.
It is known that the measures compose if one assumes various properties of
the outer function (or inner function ). This paper extends the class of
outer functions for which and compose.
A recent landmark result (Ben-David and Blais, 2020) showed that . This implies that composition holds whenever
noisyR(f) = \Tilde{\Theta}(R(f)). We show two results:
(1)When , then .
(2) If composes with respect to an outer function, then
also composes with respect to the same outer function. On the
other hand, no result of the type (for some non-trivial complexity measure )
was known to the best of our knowledge. We prove that
where is the block sensitivity of . This implies that
composes when is
asymptotically equal to .
It is already known that both and compose
when the outer function is symmetric. We also extend these results to weaker
notions of symmetry with respect to the outer function